home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 4 / ETO Development Tools 4.iso / Essentials / C++ A'Link Files / Jan 91 / CPlus.Dev$ 1⁄25⁄91 / 0263-Re >const vs #define-Jan91 < prev    next >
Encoding:
Text File  |  1991-03-06  |  3.0 KB  |  87 lines  |  [TEXT/GEOL]
  1. Item    2415334                         23-Jan-91        13:07PST
  2.  
  3. From:   V0629                           New England Digital,R & D,ASC,VAR
  4.  
  5. To:     D4682                           Marx, Peter,PRT
  6.         CPLUS.APPLE$                    C++ Interest List--Apple Employees
  7.         CPLUS.DEV$                      C++ Interest List--Developers
  8.  
  9. Item forwarded by       BEISEL       to WANG2 
  10.  
  11. ------------------------------------------------------------------------------
  12.  
  13. Sub:    RE>>const vs #define in C
  14.  
  15. Attn: Marx, Peter,PRT
  16. Attn: cplusa
  17. Attn: CPLUS
  18. SentBy: Karim Chichakly
  19. Date   1/23/91
  20. Subject    RE>>const vs #define in CFr
  21. From   Karim Chichakly
  22. To Marx, Peter,PRT, CPLUS, cplusa
  23. CC Mark Harley, Tim Schaaff, Leslie Swanson
  24.  
  25.       NewEngland                                            Interoffice Memo
  26.       Digital                     Reply to:  RE>>const vs #define in CFront
  27.                ™
  28. This is very easy to explain.  #define is not at all the same as const.
  29. #define is a preprocessor directive causing a textual substitution BEFORE the
  30. compiler scans the code.  Therefore, #define symbols do not appear in the
  31. symbol table.
  32.  
  33. consts, on the other hand, are compiler statements.  You are, in this case,
  34. generating identifiers that the compiler recognizes and tracks, hence they end
  35. up in the symbol table.  We have observed that storage space is allocated for
  36. consts (unlike constant #define's), which makes some sense.
  37.  
  38. These are the disadvantages of const over #define.  The advantage, of course,
  39. is that const's are typed and therefore the compiler can enforce strict
  40. type-checking when you use them, which is sometimes useful.  Note that you can
  41. effect the same sort of checking in a pinch with #define, by casting the value
  42. of the constant as in:
  43.  
  44. #define MAX_SHORT ((short int) 32767)         /* maximum short in value */
  45.  
  46. (also notice the use of /* & */ rather than //, which confuses some
  47. preprocessors)
  48.  
  49. --------------------------------------
  50. Date: 1/23/91
  51. To: Karim Chichakly
  52. From: Mark Harley
  53. Date: 1/23/91
  54. To: Mark Harley
  55. From: Marx, Peter,PRT
  56. Item    4605966                         23-Jan-91        00:12PST
  57.  
  58. From:   D4682                           Marx, Peter,PRT
  59.  
  60. To:     CPLUS.DEV$                      C++ Interest List--Developers
  61.         CPLUS.APPLE$                    C++ Interest List--Apple Employees
  62.  
  63. cc:     TOM.CHAVEZ                      Chavez, Thomas
  64.  
  65. Sub:    const vs #define in CFront
  66.  
  67. Dear Folks:
  68.  
  69. This is just an observation that may be useful to someone writing large C++
  70. programs. After repeatedly running out of memory in CFront using dump/load, I
  71. decided to try a little experiment.
  72.  
  73. I replaced most of the "const short int" and "const IDType" declarations with
  74. simple "#define" statements. The memory and disk space saved was phenomenal. I
  75. haven't looked at the intermediate code coming out of CFront, but I must say
  76. that this has turned out to be a very useful "feature."
  77.  
  78. Perhaps someone could fill me in on why this works so well?
  79.  
  80. Sincerely,
  81.  
  82.  
  83. Peter Marx
  84. UCLA Dept. of Medicine
  85.  
  86.  
  87.